<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        // // 值类型
        // let a = 100
        // let b = a
        // a = 200
        // console.log(b) // 100

        // // 引用类型
        // let c = {
        //     age: 18
        // }
        // let d = c
        // d.age = 21
        // console.log(c.age) // 21

        // let arr = [1, 2, 3]
        // console.log(typeof arr)

        // function C() {

        // }
        // function D() {

        // }

        // let o = new C
        // console.log(o instanceof C)
        let obj1 = {
            name: 'xueguo',
            age: 18,
            address: {
                city: 'hanzhou'
            },
            arr: ['a', 'b', 'b']
        }
        function deepClone(obj = {}) {
            if (typeof obj !== 'object' || obj == null) {
                // obj 是 null ,或者不是对象类型的时候直接返回
                return obj
            }
            let result
            if (obj instanceof Array) {
                result = []
            } else {
                result = {}
            }
            for (let key in obj) {
                // 保证 key 不是原型的属性 
                if (obj.hasOwnProperty(key)) {
                    result[key] = deepClone(obj[key])
                }
            }
            return result
        }
        let obj2 = deepClone(obj1)
        obj2.name = 'zhansan'
        obj2.arr[0] = 'c'
        console.log(obj1.name)
        console.log(obj1.arr[0])

        // 深拷贝
        function deepClone(obj) {
            if (typeof obj !== 'object' || typeof obj == null) {
                return obj
            }
            let result = obj instanceof Array ? [] : {}
            for (let key in obj) {
                if (obj.hasOwnProperty(key)) {
                    result[key] = typeof obj[key] === 'object' ? deepClone(obj[key]) : obj[key]
                }
            }
            return result
        }

        // 深拷贝
        function deepClone(obj) {
            if (typeof obj !== 'object' || typeof obj == null) {
                return obj
            }
            let result = obj instanceof Array ? [] : {}
            for (let key in obj) {
                // 保证 key 不是 obj 中的原型属性
                if (obj.hasOwnProperty(key)) {
                    result[key] = typeof obj[key] === 'object' ? deepClone(obj[key]) : obj[key]
                }
            }
            return result
        }
        // 手写bind
        Function.prototype.bind1 = function () {
            // 处理参数
            const args = Array.prototype.slice.call(arguments)
            // 获取第一个数组删除原数组
            const oneArr = args.shift()
            const self = this
            // 返回一个函数
            return function () {
                return self.apply(oneArr, args)
            }
        }

        // 深拷贝
        function deepClone(obj) {
            if (typeof obj !== 'object' || obj == null) {
                return obj
            }
            const result = obj instanceof Array ? [] : {}
            for (key in obj) {
                // 保证 key 不是 obj 中的原型属性
                if (obj.hasOwnProperty(key)) {
                    result[key] = typeof obj[key] === 'object' ? deepClone(obj[key]) : obj[key]
                }
            }
            return result
        }

        // 手写bind 函数
        Function.prototype.bind2 = function () {
            // 1.处理arguments,转化为数组
            const args = Array.prototype.slice.call(arguments)
            // 2.获取第一项
            const arrOne = args.shift()
            // 3. 获取this
            const self = this
            // 返回一个函数
            return function () {
                return self.apply(arrOne, args)
            }
        }
        // 节流 定义: 在一个时间段内，触发了事件之后，要在这个这个时间过完之后才会再次执行，如果说，定义的是两秒，那么触发事件执行函数之后的这两秒之内即使再触发多少次事件这个函数都不会再执行。
        function throttle(fn, wait = 1000) {
            let timer = null
            return function () {
                if (!timer) {
                    timer = setTimeout(() => {
                        fn.apply(this, arguments)
                        timer = null
                    }, wait)
                }
            }
        }

        // 防抖 scroll ,input 这些事件，再连续执行的事件中，触发频繁，为了减少触发。定义: 如果触发了事件，在定义的时间之内又再次触发事件，那么这个时间会重新计算。比如说两秒之内我们再次触发了时间，那么这个函数会在这次点击的基础上延迟两秒执行
        // 有两种方式实现
        // 1.时间差
        function debounce(fn, wiat) {
            
        }
    </script>
</body>

</html>